home *** CD-ROM | disk | FTP | other *** search
/ Amiga Games: Greatest Hits 1996 / Amiga Games: Greatest Hits 1996.iso / archive / userbox / publicdomain / madhouse.lha / Madhouse / developer / C-Demo / demo_german.c next >
C/C++ Source or Header  |  1996-02-11  |  11KB  |  390 lines
  1. /*    demo_german.c
  2.     Dies ist ein Beispiel-Blanker für Madhouse, mit deutschen Kommentaren.
  3.  
  4.    Hinweisen zum kompilieren des Programms:
  5.     - Vielleicht mag Dein Compiler nicht die <pragma/...>-Includes.
  6.      Dann kannst Du diese Includes evtl. weglassen, oder "pragma" muß ge-
  7.      ändert werden.
  8.     - Dieses Programm kann mit dem MaxonC++ Version 3 problemlos übersetzt
  9.      werden. Für andere Compiler kann eine Anpassung nötig werden.
  10.       
  11.     Zuletzt überarbeitet am 11.2.96 für Madhouse 2.0
  12. */
  13.  
  14.  
  15. #include <dos/dos.h>
  16. #include <intuition/intuition.h>
  17. #include <intuition/screens.h>
  18. #include <pragma/graphics_lib.h>
  19. #include <pragma/intuition_lib.h>
  20. #include <pragma/exec_lib.h>
  21. #include <pragma/dos_lib.h>
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <time.h>
  25. #include <string.h>
  26.  
  27. #define ABNC 0x40
  28. #define ABC  0x80
  29.  
  30.  
  31. /* Prototypen: */
  32. void write_stopblank();
  33. void read_prefs();
  34. void write_error( char *str );
  35.  
  36.  
  37. /* Variablen */
  38. char text[40];
  39. short color, scroll;
  40. time_t start;
  41. short duration_sec=0;
  42. struct Library *IntuitionBase = NULL;
  43. struct Library *GfxBase = NULL;
  44. struct Screen *scr = NULL;
  45. struct Window *win = NULL;
  46. struct Message *msg = NULL;
  47. USHORT DemoPalette[] = {
  48.     0x0000, 0x0FFF
  49. };
  50. struct TextAttr topaz8 = {
  51.     "topaz.font",
  52.     8,
  53.     0,
  54.     0
  55. };
  56.  
  57. /***************************************************************************
  58. ***                          open_all()
  59. ***                 Öffnet alle benötigten Dinge.
  60. ***************************************************************************/
  61.  
  62. BOOL open_all()
  63. {
  64.     IntuitionBase = OpenLibrary("intuition.library",37);
  65.     if( !IntuitionBase ) return FALSE;
  66.     GfxBase = OpenLibrary("graphics.library",37);
  67.     if( !GfxBase ) return FALSE;
  68.  
  69.     /* Einen einfachen LowRes-Screen öffnen. */
  70.     scr = OpenScreenTags(NULL,
  71.           SA_Depth,         1,
  72.           SA_Width,         320,
  73.         SA_Height,        256,
  74.           SA_Font,          &topaz8,
  75.           TAG_DONE);
  76.     if(!scr) return FALSE;
  77.     
  78.     /* Der Mauszeiger verschwindet, wenn man ihm die Farben des Hintergrunds
  79.        gibt: */
  80.     SetRGB4( &scr->ViewPort,17,0,0,0);
  81.     SetRGB4( &scr->ViewPort,18,0,0,0);
  82.     SetRGB4( &scr->ViewPort,19,0,0,0);
  83.     
  84.     win = OpenWindowTags(NULL,
  85.              WA_AutoAdjust,    TRUE,
  86.              WA_NoCareRefresh, TRUE,
  87.              WA_CustomScreen,  scr,
  88.              WA_Flags,         WFLG_RMBTRAP,
  89.              WA_Borderless,    TRUE,
  90.              WA_Activate,      TRUE,
  91.              WA_IDCMP,             IDCMP_MOUSEBUTTONS+IDCMP_RAWKEY,
  92.              TAG_DONE );
  93.     if( !win ) return FALSE;
  94.     
  95.     LoadRGB4( &scr->ViewPort, DemoPalette, 2 );
  96.     
  97.     return TRUE;
  98. }
  99.  
  100. /***************************************************************************
  101. ***                          close_all()
  102. ***             Schließt alles, was wir geöffnet hatten.
  103. ***************************************************************************/
  104.  
  105. void close_all()
  106. {
  107.     /* Diese Anweisung legt den Screen nach hinten. Dies verhindert einen
  108.        nervigen Effekt, wenn der Screen auf einem 68000-Amiga geschlossen
  109.        wird. */
  110.     if( scr )
  111.         ScreenToBack( scr );
  112.     
  113.     /* Wenn etwas schlief lief, müssen wir das Madhouse mitteilen. Aber
  114.        weil man write_error() nur einmal aufrufen darf, benötigen wir
  115.        diese nette if-Konstruktion: */
  116.     
  117.     if( !IntuitionBase ) write_error( "No intuition.lib V37!" );
  118.     else {
  119.         if( !GfxBase ) write_error( "No graphics.lib V37!" );
  120.         else {
  121.             if( !scr ) write_error( "Out of memory: Couldn't open screen.");
  122.             else {
  123.                 if( !win ) write_error( "Out of memory: Couldn't open window.");
  124.             }
  125.         }
  126.     }
  127.     
  128.     /* Jetzt schließen wir alles, was wir öffnen konnten. */
  129.     if( win ) CloseWindow( win );
  130.     if( scr ) CloseScreen( scr );
  131.     if( GfxBase ) CloseLibrary( GfxBase );
  132.     if( IntuitionBase ) CloseLibrary( IntuitionBase );
  133. }
  134.  
  135. /***************************************************************************
  136. ***                              main()
  137. ***            Hier steht nun endlich der richtige Blanker:
  138. ***************************************************************************/
  139.  
  140. void main()
  141. {
  142.     BOOL quit = FALSE;
  143.     BOOL user_quit = FALSE;
  144.     short ypos = 20;
  145.     short direction = 1;
  146.     short oldy;
  147.     
  148.     /* Zuerst lesen wir die Blanker-Einstellungen (aus dem BlankerPrefs-
  149.        Fenster) sowie den Duration-Wert, der angibt, wielange der Blanker
  150.        blanken darf. */
  151.     read_prefs();
  152.     
  153.     /* Jetzt wird die Stopp-Uhr gestartet (zum Überprüfen des Eigen-Abbruchs) */
  154.     start = time(NULL);
  155.     
  156.     /* Screen und Fenster werden geöffnet. */
  157.     if(open_all()) {
  158.         
  159.         /* Je nach Einstellung bekommt der Text eine andere Farbe: */
  160.         switch( color ) {
  161.             case 0:
  162.                 SetRGB4( &scr->ViewPort, 1, 15,0,0 );
  163.                 break;
  164.             case 1:
  165.                 SetRGB4( &scr->ViewPort, 1, 15,15,0 );
  166.                 break;
  167.             case 2:
  168.                 SetRGB4( &scr->ViewPort, 1, 0,0,15 );
  169.         }
  170.         
  171.         /* Text-Parameter: der Text wird geschrieben. */
  172.         SetAPen( win->RPort, 1 );
  173.         Move( win->RPort, 5, ypos );
  174.         Text( win->RPort, text, ( strlen(text) > 38 ? 38 : strlen(text)) );
  175.         
  176.         /* Hauptschleife. */
  177.         while( !quit ) {
  178.             
  179.             /* Wenn Scroll gewählt wurde, muß der Text bewegt werden: */
  180.             if( scroll ) {
  181.                 oldy = ypos;
  182.                 ypos += direction;
  183.                 if( (ypos > 220)  ||  (ypos < 20) ) direction *= -1;
  184.                 
  185.                 ClipBlit(win->RPort, 5, oldy-10, win->RPort, 5, ypos-10, 310, 20, ABNC | ABC );
  186.                 /* Minterme ABNC | ABC -> Rechteck ohne Veränderungen kopieren. */
  187.             }
  188.             
  189.             /* Mausknöpfe oder ein Tastendruck? */
  190.             if( msg = GetMsg(win->UserPort) ) {
  191.                 quit = TRUE;
  192.                 user_quit = TRUE;
  193.                 ReplyMsg( msg );
  194.             }
  195.             
  196.             /* Wenn 'Change Blanker' im Hauptfenster aktiviert wurde
  197.                (duration_sec ist ungleich null) UND wir schon etwas länger
  198.                blanken als erlaubt (difftime(time(NULL),start) > time_counter)
  199.                dann müssen wir schlußmachen. */
  200.             if( duration_sec && difftime(time(NULL),start) > duration_sec )
  201.                 quit = TRUE;
  202.             
  203.             WaitTOF();
  204.         }
  205.         
  206.     }
  207.     
  208.     /* Alles Angeforderte schließen (und vielleicht einen Fehler schreiben): */
  209.     close_all();
  210.     
  211.     /* Wenn unser Blanker durch den Anwender beendet wurde, müssen wir das Mad-
  212.        house mitteilen (sonst würde es [bei aktivertem Change Blanker] den
  213.        nächsten Blanker starten. */
  214.     
  215.     if( user_quit )
  216.         write_stopblank();
  217.     
  218.     /* Und fertig! */
  219. }
  220.  
  221.  
  222. /***************************************************************************
  223. ***                                                                      ***
  224. ***              Funktionen zur Verständigung mit Madhouse               ***
  225. ***                                                                      ***
  226. ***************************************************************************/
  227.  
  228. /* Einige globale Variablen: */
  229.  
  230. char bu[1500];        /* Der Speicherbereich bu[] enthält die gesamte prefs-
  231.                          Datei. */
  232. short bu_seek = 0;    /* bu_seek ist der Offset von bu[]. Er gibt an, wo sich
  233.                          die "Lesemarke" in bu befindet, ab der der nächste
  234.                          Parameter gelsen wird. */
  235.  
  236. /* Erstmal einige nützliche Funktionen: */
  237.  
  238. /***************************************************************************
  239. ***                          read_next_digit()
  240. ***              Liest die nächste Nummer aus der prefs-Datei.
  241. ***              (Der nächste Parameter muß eine Nummer sein.)
  242. ***************************************************************************/
  243.  
  244. long read_next_digit()
  245. {
  246.     short number_cnt = 0;
  247.     char number[50];
  248.     
  249.     while( bu[bu_seek] != (char) 0x0A ) {
  250.         number[number_cnt] = bu[bu_seek];
  251.         bu_seek++;
  252.         number_cnt++;
  253.     }
  254.     number[number_cnt] = (char) 0x00;
  255.  
  256.     /*  Das 0x0A am Zeilenende muß übersprungen werden. */
  257.     bu_seek+=1;
  258.     
  259.     return strtol( number, 0, 10 );
  260. }
  261.  
  262. /***************************************************************************
  263. ***                          read_next_string()
  264. ***             Liest die nächste Zeichenkette aus der prefs-Datei.
  265. ***             (Der nächste Parameter muß eine Zeichenkette sein.)
  266. **************************************************************************/
  267.  
  268. void read_next_string( char *string, short maxlen )
  269. {
  270.     short text_cnt = 0;
  271.     
  272.     /* Ein Madhouse-Text beginnt aus technischen Gründen (Aha) mit "$".
  273.        Weil wir das "$" nicht benötigen, überspringen wir einfach das
  274.        nächste Zeichen. */
  275.     bu_seek++;
  276.     
  277.     while( (bu[bu_seek] != (char) 0x0A)  &&  (text_cnt < maxlen)  ) {
  278.         string[text_cnt] = bu[bu_seek];
  279.         bu_seek++;
  280.         text_cnt++;
  281.     }
  282.     
  283.     string[text_cnt] = (char) 0x00;
  284.     /* Jetzt haben wir den Text in string[]. */
  285.     
  286.     /*
  287.      *  Das 0x0A überspringen.
  288.      */
  289.     
  290.     bu_seek+=1;
  291. }
  292.  
  293.  
  294.  
  295. /***************************************************************************
  296. ***                             read_prefs()
  297. ***                       Liest die Einstellungen.
  298. ***************************************************************************/
  299.  
  300. void read_prefs()
  301. {
  302.     short text_cnt = 0;
  303.     short number_cnt = 0;
  304.     BPTR f = NULL;
  305.     
  306.     f = Open( "RAM:Madhouse_Storage/prefs", MODE_OLDFILE );
  307.     if (f) {
  308.         Read( f, bu, sizeof( bu ) );
  309.         
  310.         /* Nun hat bu[] zum Beispiel so einen Inhalt:
  311.            "$Hello, this is a text(0x0A)2(0x0A)0(0x0A)
  312.            5(0x0A)RAM:Madhouse_Storage(0x0A)".
  313.            Die beiden Zeichen (0x0D) und (0x0A) sind zwischen jeder Zeile.
  314.            Hello,... ist unser erste Parameter. 2 ist der Zweite (die
  315.            Farbe des Textes), 0 der Dritte (Scrollen ja/nein), 5 ist
  316.            der Duration-Wert in Minuten und RAM:... ist der Pfad unseres
  317.            Verzeichnisses, falls wir eine Datei nachladen möchten.
  318.            Alle Madhouse-Strings beginnen mit "$".
  319.            Der erste Parameter wird in text[] verfrachtet, der Zweite kommt
  320.            in color, der Dritte in duration_sec und den Pfad brauchen wir
  321.            gar nicht. */
  322.         
  323.         /*
  324.          *   Erster Parameter (Text)
  325.          */
  326.          
  327.         read_next_string( text, 40 );
  328.         
  329.         /*
  330.          *   Zweiter Parameter (Color)
  331.          */
  332.         
  333.         color = read_next_digit();
  334.         
  335.         /*
  336.          *  Dritter Parameter (Scroll)
  337.          */
  338.         
  339.         scroll = read_next_digit();
  340.         
  341.         /*
  342.          *  Duration-Parameter.
  343.          */
  344.         
  345.         duration_sec = read_next_digit() * 60; /*Minuten -> Sekunden*/
  346.         
  347.         Close( f );
  348.     } else {     /* Der Blanker wurde nicht von Madhouse gestarten: Abbruch! */
  349.         exit(0);
  350.     }
  351. }        
  352.  
  353. /***************************************************************************
  354. ***                           write_stopblank()
  355. ***   Muß benutzt werden, wenn der Blanker durch den Anwender abgebrochen
  356. ***               wurde, und nicht durch den Duration-Wert.
  357. ***************************************************************************/
  358.  
  359. void write_stopblank()
  360. {
  361.     /* Wir müssen nur eine neue, leere Datei anlegen, schon weiß Madhouse
  362.        bescheit. */
  363.     
  364.     BPTR f;
  365.     f = Open( "RAM:Madhouse_Storage/stopblank", MODE_NEWFILE );
  366.     if( f )
  367.         Close( f );
  368. }
  369.  
  370. /***************************************************************************
  371. ***                              write_error()
  372. ***  Macht Madhouse klar, daß ein Fehler auftrat (und wie der Fehler heißt)
  373. ***************************************************************************/
  374.  
  375. void write_error( char *str )
  376. {
  377.     BPTR f;
  378.     
  379.     f = Open( "RAM:Madhouse_Storage/errors", MODE_READWRITE );
  380.     if( f ) {
  381.         Seek( f, 0, OFFSET_END );
  382.         Write( f, str, strlen(str) );
  383.         Close( f );
  384.     } 
  385. }
  386.  
  387.  
  388.  
  389.  
  390.